// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV }) // 使用当前云环境
const db = cloud.database()
const userCollection = db.collection('users')
const crypto = require('crypto')

// 生成随机token
function generateToken() {
    return crypto.randomBytes(32).toString('hex')
}

// 密码加密
function encryptPassword(password) {
    const hash = crypto.createHash('sha256')
    hash.update(password)
    return hash.digest('hex')
}

// 云函数入口函数
exports.main = async (event, context) => {
    const { action, data } = event

    switch (action) {
        case 'add':
        case 'create':
            return await addUser(data)
        case 'update':
            return await updateUser(data)
        case 'delete':
            return await deleteUser(data)
        case 'get':
            return await getUser(data)
        case 'list':
            return await listUsers(data)
        case 'login':
            return await loginUser(data)
        case 'initAdmin':
            return await initAdminUser()
        default:
            return {
                success: false,
                message: '未知操作类型'
            }
    }
}

// 添加用户
async function addUser(data) {
    try {
        const { username, password } = data

        if (!username || !password) {
            return {
                success: false,
                message: '用户名和密码不能为空'
            }
        }

        // 检查用户名是否已存在
        const checkResult = await userCollection.where({
            username: username
        }).get()

        if (checkResult.data.length > 0) {
            return {
                success: false,
                message: '用户名已存在'
            }
        }

        // 生成token和加密密码
        const token = generateToken()
        const encryptedPassword = encryptPassword(password)

        // 构建简化的用户数据 - 只保留核心字段
        const userData = {
            username: username,
            password: encryptedPassword,
            createTime: new Date(),
            token: token
        }

        // 写入数据库
        const result = await userCollection.add({
            data: userData
        })

        return {
            success: true,
            message: '添加用户成功',
            _id: result._id
        }
    } catch (error) {
        return {
            success: false,
            message: '添加用户失败',
            error: error.message
        }
    }
}

// 更新用户
async function updateUser(data) {
    try {
        const { _id, username, password } = data

        if (!_id) {
            return {
                success: false,
                message: '用户ID不能为空'
            }
        }

        // 检查是否为管理员用户
        const userResult = await userCollection.doc(_id).get()
        if (userResult.data && userResult.data.username === 'admin') {
            return {
                success: false,
                message: '管理员用户不允许修改'
            }
        }

        const updateData = {}

        // 只允许更新用户名和密码
        if (username) {
            updateData.username = username
        }

        if (password) {
            updateData.password = encryptPassword(password)
            // 密码更新时重新生成token
            updateData.token = generateToken()
        }

        if (Object.keys(updateData).length === 0) {
            return {
                success: false,
                message: '没有需要更新的数据'
            }
        }

        const result = await userCollection.doc(_id).update({
            data: updateData
        })

        return {
            success: true,
            message: '更新用户成功',
            updated: result.stats.updated
        }
    } catch (error) {
        return {
            success: false,
            message: '更新用户失败',
            error: error.message
        }
    }
}

// 删除用户
async function deleteUser(data) {
    try {
        const { _id } = data

        if (!_id) {
            return {
                success: false,
                message: '用户ID不能为空'
            }
        }

        // 检查是否为管理员用户
        const userResult = await userCollection.doc(_id).get()
        if (userResult.data && userResult.data.username === 'admin') {
            return {
                success: false,
                message: '管理员用户不允许删除'
            }
        }

        const result = await userCollection.doc(_id).remove()

        return {
            success: true,
            message: '删除用户成功',
            deleted: result.stats.removed
        }
    } catch (error) {
        return {
            success: false,
            message: '删除用户失败',
            error: error.message
        }
    }
}

// 获取单个用户
async function getUser(data) {
    try {
        const { _id } = data

        if (!_id) {
            return {
                success: false,
                message: '用户ID不能为空'
            }
        }

        const result = await userCollection.doc(_id).get()

        if (result.data) {
            // 不返回密码，但返回其他字段
            const { password, ...userInfo } = result.data
            return {
                success: true,
                data: userInfo
            }
        } else {
            return {
                success: false,
                message: '用户不存在'
            }
        }
    } catch (error) {
        return {
            success: false,
            message: '获取用户失败',
            error: error.message
        }
    }
}

// 获取用户列表
async function listUsers(data) {
    try {
        const { page = 1, pageSize = 10, username = '' } = data
        const skip = (page - 1) * pageSize

        // 构建查询条件
        let query = userCollection.where({})

        if (username) {
            query = query.where({
                username: db.RegExp({
                    regexp: username,
                    options: 'i'
                })
            })
        }

        // 获取总数
        const countResult = await query.count()

        // 获取分页数据
        const listResult = await query
            .skip(skip)
            .limit(pageSize)
            .orderBy('createTime', 'desc')
            .get()

        // 处理返回数据，不返回密码
        const users = listResult.data.map(user => {
            const { password, ...rest } = user
            return rest
        })

        return {
            success: true,
            data: users,
            total: countResult.total,
            page,
            pageSize
        }
    } catch (error) {
        return {
            success: false,
            message: '获取用户列表失败',
            error: error.message
        }
    }
}

// 用户登录
async function loginUser(data) {
    try {
        const { username, password } = data

        if (!username || !password) {
            return {
                success: false,
                message: '用户名和密码不能为空'
            }
        }

        // 首先检查用户是否存在
        const userCheckResult = await userCollection.where({
            username: username
        }).get()

        if (userCheckResult.data.length === 0) {
            return {
                success: false,
                message: '用户不存在，请联系管理员'
            }
        }

        // 用户存在，验证密码
        const encryptedPassword = encryptPassword(password)
        const passwordCheckResult = await userCollection.where({
            username: username,
            password: encryptedPassword
        }).get()

        if (passwordCheckResult.data.length === 0) {
            return {
                success: false,
                message: '密码错误，请检查后重试'
            }
        }

        const user = passwordCheckResult.data[0]

        // 生成新的token
        const newToken = generateToken()

        // 更新用户token和最后登录时间
        await userCollection.doc(user._id).update({
            data: {
                token: newToken,
                lastLoginTime: new Date()
            }
        })

        // 返回用户信息（不包含密码）
        const { password: _, ...userInfo } = user

        return {
            success: true,
            message: '登录成功',
            data: {
                ...userInfo,
                token: newToken,
                role: userInfo.role || 'admin'
            }
        }
    } catch (error) {
        console.error('登录函数错误:', error)
        return {
            success: false,
            message: '登录失败，系统错误',
            error: error.message
        }
    }
}

// 初始化管理员用户
async function initAdminUser() {
    try {
        // 检查管理员用户是否已存在
        const checkResult = await userCollection.where({
            username: 'admin'
        }).get()

        if (checkResult.data.length > 0) {
            return {
                success: true,
                message: '管理员用户已存在'
            }
        }

        // 创建管理员用户
        const token = generateToken()
        const encryptedPassword = encryptPassword('12345678')

        const adminData = {
            username: 'admin',
            password: encryptedPassword,
            createTime: new Date(),
            token: token
        }

        const result = await userCollection.add({
            data: adminData
        })

        return {
            success: true,
            message: '管理员用户初始化成功',
            _id: result._id
        }
    } catch (error) {
        return {
            success: false,
            message: '管理员用户初始化失败',
            error: error.message
        }
    }
}
